package com.ywk.base.java8.function;

import java.util.Random;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;

/**
 * 出现背景：可以对某些匿名内部类的写法进行简化
 * 函数式接口（Lambda表达式：("入参")->{...}）
 * @Author zbh
 * @Date 2023/1/17
 */
public class FunctionTest {

    public static void main(String[] args) {
        //消费型接口 Consumer：有参数，没有返回值，方法：
        Consumer<String> c1=(String s)->{System.out.println(s);};//泛型 String 为入参类型
        //简写
//        Consumer<String> c1=System.out::println;
        c1.accept("aaa");
        //供应型接口 Supplier： 无参数，有返回值，方法：get
        Supplier<Integer> s1=()->{return new Random().nextInt(10);};//生成0-9的随机整数，泛型 Integer 为返回值类型
        int v1 = s1.get();
        System.out.println(v1);
        //功能型接口 Function：有参数，有返回值，方法：apply
        Function<String,Integer> f1=(String s)->{return Integer.valueOf(s);};//泛型 String 为入参类型，泛型 Integer 为返回值类型
        Integer v2 = f1.apply("123");
        System.out.println(v2);
        //断言型接口 Predicate 有参数，有返回值，但返回值是 boolean，方法：test
        Predicate<String> p1=(String s)->{return s.equals("aaa");};//泛型 String 为入参类型
        boolean b1 = p1.test("aaa");
        System.out.println(b1);


        //多重函数
        System.out.println("-----");
        Consumer<String> c2=(String s)->{System.out.println(s.length());};
        c1.andThen(c2).accept("123");//先执行c1再执行c2
        Predicate<String> p2=(String s)->{return s.contains("1");};
        System.out.println(p1.and(p2).test("111"));
        System.out.println(p1.or(p2).test("111"));
    }
}
